Application programming interfaces (APIs) generally expose various routines and methods to software developers for use in obtaining and modifying data using features of a software application. These APIs may be accessible programmatically (e.g., as function calls programmed in an application or function library) or via a web resource for web-based applications. Web-based applications can invoke functionality exposed by an API, for example, using a Representational State Transfer function call (a RESTful function call). A RESTful call generally uses HTTP requests to invoke a function exposed by a web-based API and provide data to the invoked function for processing. In other cases, web-based applications can invoke API functions using queries encapsulated in, for example an HTTP POST request, a Simple Object Access Protocol (SOAP) request, or other protocols that allow client software to invoke functions on a remote system.
API functions generally provide for the ability to commit data objects to a data store or retrieve specified data from a data store. These data objects may include a plurality of attributes that define various properties of the data object to be committed to or retrieved from a data store. The attributes included in a data object may be defined as primitive data types—data types that are natively supported by a programming language (e.g., integers, long integers, single and double precision floating point numbers, characters, strings, Boolean values, etc.)—or other data objects. The attributes included in a data object may also include information identifying the source of each attribute.
To resolve data objects requested when a client application invokes an API function, a system may generate a plurality of queries against a data store to request the specified data objects. In some cases, the plurality of queries may be generated against a single instance of a data store. While data objects may be stored in and retrieved from a single instance of a data store, reliance on a single instance of a data store may have performance and reliability implications. For example, because each API function may result in the generation of a plurality of discrete queries against the data store, processing latencies may occur in the resolution of the requested data objects from the execution of a series of requests for a specific invocation of the API function call. Further, because the queries generated from an API query may not be executed atomically (i.e., all the queries associated with a single API query may not be executed before queries associated with a different API query are executed), additional delays may be introduced into the resolution of the requested data objects. Still further, maintaining a single data store may create a single point of failure for software systems that rely on the data exposed by the API.
Thus, what are needed are systems and methods for efficiently processing API function calls involving the resolution of data objects.